import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
import java.util.*;
import java.awt.Color;

/**
 * FarmWorld es el escenario donde se desarrolla juego.
 * 
 * @author (Gabriela Alvarado) 
 * @version (mayo 2013)
 */
public class FarmWorld extends World
{
    private PollitoM pollitoM;
    private GallinaM gallinaM;
    private OvejaM ovejaM;
    private VacaM vacaM;
    private CerditoM cerditoM;

    private GreenfootSound sound;

    private Reloj reloj;
    private Corazon corazon;
    private LPuntos lPuntos;

    private Contador contador;
    private Contador tiempo;
    private Contador puntos;
    private Contador vidas;

    //private Barra barra;
    private int dificultad;
    private boolean bTime;
    private int selectorA;

    /**
     * Constructor de FarmWorld.
     * 
     */
    public FarmWorld()
    {    
        super(700,560, 1, false); 
        dificultad=0;
        bTime=false;
        this.prepare();
        selectorA=0;
        sound = new GreenfootSound("sonido2.mp3");
        lPuntos= new LPuntos("Puntos");
        addObject(lPuntos,33,545);

    }

    /**
     * Controla el grado de dificultad del juego segun el tiempo.
     * Decrementa el contador de tiempo.
     * Reproduce la cancion de fondo.
     * Hace referencia a jugar.
     */
    public void act()
    {

        if(tiempo.contador()==6000)
            dificultad=1;
        if(tiempo.contador()==4000)
        {    dificultad=2;
             sound.stop();
             sound.play();
        }
        tiempo.decrementa(1); 
        sound.playLoop();
        this.jugar();
        

    }

    /**
     * Regresa el contador de puntos.
     */
    public void puntos(int unaCantidad)
    {
        puntos.incrementa(unaCantidad);
    }

    /**
     * Contiene todos los metodos necesarios para el desarrollo
     * del juego.
     * Controla los espacios de tiempo para generar productos 
     * en los animales.
     * Activa una bandera si termina el tiempo de juego.
     */
    public void jugar()
    {
        this.attack();
        this.menu();
        this.agregaAnimal();
        this.tomaProducto();
        int num= Greenfoot.getRandomNumber(5000);

        if (num < 80)
            this.generaProductos();
        this.checaLimites();

        if (tiempo.contador() <=0)
            bTime=true;
    }

    /**
     * Depende de la dificultad sera el ataque de los tractores.
     */
    public void attack()
    {
        if (dificultad==0)
            this.attackEasy();
        else if (dificultad==1)
            this.attackMedium();
        else if (dificultad==2)
            this.attackHard();
    }

    /**
     * Regresa el contador de vidas.
     */
    public Contador vidas()     
    {    return vidas;
    }

    /**
     * Determina el termino del juego.
     * Guarda la puntuacion del jugador.
     * Detiene la cancion de fondo.
     * Dependiendo de la bandera de tiempo
     * determina si se gano o se perdio y crea un
     * mundo acorde al resultado.
     */
    public void checaLimites()
    {   

        if (vidas.contador()<=0 || bTime==true)
        {     

            sound.stop();

            if(UserInfo.isStorageAvailable())
            {
                UserInfo myInfo=UserInfo.getMyInfo();
                myInfo.setScore(puntos.contador());
                myInfo.store();
            }

            if (bTime==false)
            {   
                GameOver gameOver = new GameOver();
                Greenfoot.setWorld(gameOver);
            }

            if (bTime==true)
            {
                Win win = new Win();
                Greenfoot.setWorld(win);
            }

        }
    }

    /**
     * Guarda en una lista todos los productos existentes en el escenario 
     * en ese momento, si se da click en alguno de ellos desaparece
     * el prodcuto y se incrementa el contador de dinero segun su valor.
     * 
     */
    public void tomaProducto()
    {    
        List<Actor> lista;
        MouseInfo mouse = Greenfoot.getMouseInfo(); 

        lista= getObjects(Producto.class);
        Actor producto;

        if (lista.size()>0)
        {
            for(int i=0; i< lista.size(); i++)
            {
                producto= lista.get(i);
                if (  Greenfoot.mouseClicked(producto) )
                {    removeObject(producto);

                    if ( producto.getClass() == Lana.class)
                        contador.incrementa(25);

                    if ( producto.getClass() == Huevos.class)
                        contador.incrementa(20);

                    if ( producto.getClass() == Chuleta.class)
                        contador.incrementa(15);

                    if ( producto.getClass() == Leche.class)
                        contador.incrementa(10);

                }
            }
        }

    }

    /**
     * Guarda en una lista todos los animales existentes en el escenario 
     * en ese momento, genera una posicion aleatoria desde 0 hasta el tamano
     * de la lista y el animal de esa posicion producira un producto.
     */
    public void generaProductos()
    {
        List<Object> lista;
        Object animal;

        lista= getObjects(Animal.class);

        if (lista.size()>0)
        {          animal= lista.get( Greenfoot.getRandomNumber (lista.size()) );
            ( (Animal) animal).produce();
        }

    }

    /**
     * Segun el selector al dar click en algun lugar del escenario 
     * se agrega el animal elegido y se decrementa el contador de dinero
     * segun su valor.
     * Solo se pueden comprar animales si se cuenta son suficiente dinero.
     */
    public void agregaAnimal()
    {   
        if (Greenfoot.mouseClicked(this))
        {          MouseInfo mouse = Greenfoot.getMouseInfo(); 

            switch (selectorA)
            {    
                case 1: if ( contador.contador()-20 >= 0)
                {    addObject (new Pollito(),mouse.getX(),mouse.getY());
                    contador.decrementa(20);
                }
                break;

                case 2: if (contador.contador()-40 >= 0)
                {     addObject (new Gallina(),mouse.getX(),mouse.getY());      
                    contador.decrementa(40);
                }
                break;

                case 3: if (contador.contador()-60 >= 0)
                {     addObject (new Vaca(),mouse.getX(),mouse.getY());      
                    contador.decrementa(60);
                }
                break;

                case 4: if (contador.contador()-80 >=0 )
                {     addObject (new Cerdito(),mouse.getX(),mouse.getY());      
                    contador.decrementa(80);
                }
                break;

                case 5: if (contador.contador()-30 >=0 )
                {     addObject (new Oveja(),mouse.getX(),mouse.getY());      
                    contador.decrementa(30);
                }
                break;

            }
            selectorA=0;
        }
    }

    /**
     * Cambia el valor del selector al dar clic en alguno de los animales del menu.
     */
    public void menu()
    {   
        MouseInfo mouse = Greenfoot.getMouseInfo(); 

        if (Greenfoot.mouseClicked(pollitoM))
            selectorA=1;        

        else if (Greenfoot.mouseClicked(gallinaM))
            selectorA=2;

        else if (Greenfoot.mouseClicked(vacaM))
            selectorA=3;

        else if (Greenfoot.mouseClicked(cerditoM))
            selectorA=4;

        else if (Greenfoot.mouseClicked(ovejaM))
            selectorA=5;

    }

    /**
     * Genera el ataque mas dificil de vencer en el juego.
     * Crea aleatoriamente todo tipo de tractores.
     */
    public void attackHard()
    {   int num= Greenfoot.getRandomNumber(1000);

        if ( num>0 && num <= 5) 
        {
            attackVerde(num);
        }
        else if ( num>5 && num <= 10) 
        {
            attackRojo(num);
        }
        else if ( num>10 && num <= 15) 
        {
            attackAmarillo(num);
        }
        else if ( num>15 && num <= 20) 
        {
            attackAzul(num);
        }
        else if ( num>20 && num <= 25) 
        {
            attackMorado(num);
        }
    }

    /**
     * Es el ataque mas facil del juego, solo crea de 
     * manera aleatoria los tractores mas lentos.
     */
    public void attackEasy()
    {
        int num= Greenfoot.getRandomNumber(1000);

        if ( num>5 && num <= 10) 
        {
            attackRojo(num);
        }
        else if ( num>15 && num <=30) 
        {
            attackAzul(num);
        }

    }

    /**
     * Genera el ataque de media dificultad en el juego,
     * crea tractores lentos y de velocidad media.
     */
    public void attackMedium()
    {
        int num= Greenfoot.getRandomNumber(400);

        if ( num>0 && num <= 5) 
        {
            attackVerde(num);
        }
        else if ( num>5 && num <=10) 
        {
            attackRojo(num);
        }

        else if ( num>15 && num <=20) 
        {
            attackRojo(num);
        }

    }

    /**
     * Crea tractores verdes de manera aleatoria en las 5 lineas de ataque.
     */
    public void attackVerde(int aNum)
    {  
        switch(aNum)
        {     case 1: addObject(new Tverde(8), 700,115);
            break;
            case 2: addObject(new Tverde(8), 700,215); 
            break;
            case 3: addObject(new Tverde(8), 700,315); 
            break;
            case 4: addObject(new Tverde(8), 700,400); 
            break;
            case 5: addObject(new Tverde(8), 700,500); 
            break;
        }

    }

    /**
     * Crea tractores rojos de manera aleatoria en las 5 lineas de ataque.
     */
    public void attackRojo(int aNum)
    {   
        switch(aNum)
        {     case 6: addObject(new Trojo(10), 700,115);
            break;
            case 7: addObject(new Trojo(10), 700,215); 
            break;
            case 8: addObject(new Trojo(10), 700,315); 
            break;
            case 9: addObject(new Trojo(10), 700,400); 
            break;
            case 10: addObject(new Trojo(10), 700,500); 
            break;
        }

    }

    /**
     * Crea tractores amarillos de manera aleatoria en las 5 lineas de ataque.
     */
    public void attackAmarillo(int aNum)
    {  
        switch(aNum)
        {     case 11: addObject(new Tamarillo(13), 700,115);
            break;
            case 12: addObject(new Tamarillo(13), 700,215); 
            break;
            case 13: addObject(new Tamarillo(13), 700,315); 
            break;
            case 14: addObject(new Tamarillo(13), 700,400); 
            break;
            case 15: addObject(new Tamarillo(13), 700,500); 
            break;
        }

    }

    /**
     * Crea tractores azules de manera aleatoria en las 5 lineas de ataque.
     */
    public void attackAzul(int aNum)
    {   
        switch(aNum)
        {     case 16: addObject(new Tazul(7), 700,115);
            break;
            case 17: addObject(new Tazul(7), 700,215); 
            break;
            case 18: addObject(new Tazul(7), 700,315); 
            break;
            case 19: addObject(new Tazul(7), 700,400); 
            break;
            case 20: addObject(new Tazul(7), 700,500); 
            break;
        }

    }

    /**
     * Crea tractores morados de manera aleatoria en las 5 lineas de ataque.
     */
    public void attackMorado(int aNum)
    {   
        switch(aNum)
        {     case 21: addObject(new Tmorado(18), 700,115);
            break;
            case 22: addObject(new Tmorado(18), 700,215); 
            break;
            case 23: addObject(new Tmorado(18), 700,315); 
            break;
            case 24: addObject(new Tmorado(18), 700,400); 
            break;
            case 25: addObject(new Tmorado(18), 700,500); 
            break;
        }

    }

    /**
     * Crea los abjetos que aparecen al inicio del juego.
     */
    public void prepare()
    {
        vidas= new Contador(6);
        addObject(vidas,170, 545);

        tiempo= new Contador(8000);
        addObject(tiempo,265, 545);

        contador = new Contador(300);
        addObject(contador,660, 30);

        puntos = new Contador(0);
        addObject(puntos,100, 545);

        corazon= new Corazon();
        addObject(corazon,149,545);

        reloj= new Reloj();
        addObject(reloj,225,545);

        //barra= new Barra();
        //addObject(barra,510,545);

        pollitoM= new PollitoM();
        addObject(pollitoM,315,35);

        gallinaM= new GallinaM();
        addObject(gallinaM,400,38);

        ovejaM= new OvejaM();
        addObject(ovejaM,500,35);

        vacaM= new VacaM();
        addObject(vacaM,140,35);

        cerditoM= new CerditoM();
        addObject(cerditoM,230,35);

    }
}
